#define  _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>



//AC 770.单词替换 -- 2024.12.1

//#include<stdio.h>
//int main()
//{
//    int n = 0;
//    char s[100][101];
//    char a[101];
//    char b[101];
//    while (n < 100 && scanf("%s", s[n]) == 1)//可以把输入缓冲区的字符们一截截地全输入完
//    {
//        n++;
//        char ch = getchar();//返回输入的字符的ASCII值
//        if (ch == '\n')
//            break;
//    }
//    scanf("%s %s", a, b);
//    for (int i = 0;i < n;i++)
//    {//strcmp也是找\0停下得字符串
//        if (strcmp(s[i], a) == 0)
//            printf("%s ", b);
//        else
//            printf("%s ", s[i]);
//    }
//    return 0;
//}

//char a[2][3];//全局变量里面的值是初始化为0
//int b;
//int main()
//{
//    if (a[0][0] == 0)
//        printf("hehe\n");
//    if (b == 0);
//    printf("hello\n");
//    return 0;
//}

//#include<stdio.h>
//char s[100][101];
//int main()
//{
//    int n = 0, i = 0;
//    char a[101];
//    char b[101];
//    while (n < 100 && scanf("%s", s[n]) == 1)
//    {
//        n++;
//        char ch = getchar();
//        if (ch == '\n')
//            break;
//    }
//    scanf("%s %s", a, b);
//    while (s[i][0] > 0)
//    {
//        if (strcmp(s[i], a) == 0)
//            printf("%s ", b);
//        else
//            printf("%s ", s[i]);
//        i++;
//    }
//    return 0;
//}



//int main()
//{     //3
//    int a = 3.94;
//    printf("%d\n", a);
//    return 0;
//}



//int main()
//{
//    printf("%.2lf\n", 2);//%lf打印要小数，给整数不行
//    printf("%.2lf\n", 15 * 233333 * 342720 * 15 * 233333 * 342720);
//
//    printf("%.2lf\n", 15 * 233333 * 342720 * 15 * 233333 * 342720.0);
//           //在前面还是整数运算，在整数int范围里的，溢出了
//
//                    //这里就全在double范围里运算了
//    printf("%.2lf\n", 15.0 * 233333 * 342720 * 15 * 233333 * 342720);
//    printf("%.2lf\n", 15.0 * 233333 * 342720 * 15 * 233333 * 342720.0);//结果一样
//
//    return 0;
//}



//int main()
//{
//    for (int i = 0;i < 2;i++)
//    {
//        while (1)
//        {
//         printf("hehe\n");
//         break;//break只退最近那层的循环
//        }
//        printf("hehe\n");
//    }
//    return 0;
//}



//2024蓝桥真题 3.好数 -- 2024.12.2

//#include <stdio.h>
//#include <stdlib.h>
//int main(int argc, char* argv[])
//{
//    // 请在此输入您的代码
//    long long n;
//    int count = 0;
//    scanf("%lld", &n);
//    for (int i = 1;i <= n;i++)
//    {
//        int flag = 0;
//        int a = i;
//        while (a)
//        {
//            int muo = a % 10;
//            if (muo % 2 != 1)
//            {
//                flag = 1;
//                break;
//            }
//            a = a / 10;//动i,i加不起来死循环了
//            if (a != 0)
//            {
//                muo = a % 10;
//                if (muo % 2 != 0)
//                {
//                    flag = 1;
//                    break;
//                }
//                a /= 10;
//            }
//        }
//        if (flag == 0)
//            count++;
//    }
//    printf("%d", count);
//    return 0;
//}



//最小公倍数 = 两数相乘 / 最大公因数

//int main()
//{
//    int a, b;
//    scanf("%d %d", &a, &b);
//    if (a > b)
//    {
//        int change = a;
//        a = b;
//        b = change;
//    }
//    int i;
//    //while (n--)//遍历n-1~0
//    ////5判断可以进来，一进就减1，遍历的是4~0
//    //{
//    //    if (a % n == 0 && b % n == 0)
//    //        break;
//    //}
//    for (i = a; i > 0; i--)
//    {
//        if (a % i == 0 && b % i == 0)
//        {
//            break;
//        }
//    }
//    printf("%d\n", a * b /i );
//    return 0;
//}



//while(scanf("%s",arr)==1)也是循环至输错地输入，但结束循环输入条件里面也有，最后共同设置成了符题目要求的

//int main()
//{
//    int arr[100],count = 0;
//    while (scanf("%s", arr) == 1)
//    {
//        count++;
//        if (getchar() == '\n')
//        {
//            break;
//        }
//    }
//    printf("%d\n", count);
//    return 0;
//}



//AC 775.倒排单词 2024.12.3

//输入
//cHXPoPeTAoN obAgoRXTnUWtSpZsGEdPBF N idiid wTHgmWP Mr P wHQV hXW bYFjoopxCzS Qz TtMt SE ObezZsagTh
//输出
// ObezZsagTh SE TtMt Qz bYFjoopxCzS hXW wHQV P Mr wTHgmWP idiid N obAgoRXTnUWtSpZsGEdPBF cHXPoPeTAoN
//多了个空格

//#include<stdio.h>
//int main()
//{
//    char arr[100][100];
//    int i = 0;
//    while (scanf("%s", arr[i]) == 1)
//    {
//        i++;
//        if (getchar() == '\n')
//            break;
//        //err  
//  //for (i = i;i >= 0;i--)
//    for (i = i - 1;i>=0;i--)
//    {   //right
//        printf("%s ", arr[i]);
//    }
//    return 0;
//}



//int main()
//{
//    int i;
//    for (i = 0;i <= 3;i++)
//    {
//        printf("hehe\n");
//    }
//    printf("%d\n", i);//4
//    for (int j = 1;j < 2;j--)
//    { //第一次进也要判断能否进再进
//        printf("hello\n");
//    }
//    return 0;
//}



//AC 776.字符串移位包含问题 -- 2024.12.6

//#include<stdio.h>
//#include<string.h>
//int a, b;
//char arr[31], brr[31];
//void text()
//{
//    if (a > b)
//    {                    //a-1 --> err
//        for (int i = 0;i < a;i++)//所有移位情况是a-1但第一次比时是非移位直接比的那次
//        {
//            int count = 0;
//            for (int j = 0;j <= a - b;j++)//每种情况找到这就停就行了
//            {
//                int c = j;
//                while (arr[c] == brr[c] && brr[c] != 0)
//                {
//                    count++;
//                    c++;
//                }
//                if (count == b)
//                {
//                    printf("true");
//                    return 0;
//                }
//            }
//            char f;
//            for (int d = 0;d < a;d++)
//            {
//                if (d == 0)
//                {
//                    f = arr[d];
//                }
//                else
//                {
//                    arr[d - 1] = arr[d];
//                }
//                if (d == a - 1)
//                {
//                    arr[d] = f;
//                }
//            }
//        }
//        printf("false");
//    }
//    else
//    {
//        for (int i = 0;i < b;i++)
//        {
//            int count = 0;
//            for (int j = 0;j <= b - a;j++)
//            {
//                int c = j;
//                while (arr[c] == brr[c] && arr[c] != 0)
//                {
//                    count++;
//                    c++;
//                }
//                if (count == a)
//                {
//                    printf("true");
//                    return 0;
//                }
//            }
//            char f;
//            for (int d = 0;d < b;d++)
//            {
//                if (d == 0)
//                {
//                    f = brr[d];
//                }
//                else
//                {
//                    brr[d - 1] = brr[d];
//                }
//                if (d == b - 1)
//                {
//                    brr[d] = f;
//                }
//            }
//        }
//        printf("false");
//    }
//}
//int main()
//{
//    scanf("%s%s", arr, brr);
//    a = strlen(arr);
//    b = strlen(brr);
//    text();
//    return 0;
//}

//void text()
//{
//    while (1)
//    {
//        printf("hehe\n");
//        return 0;//返回类型是void也是停
//    }
//}
//int main()
//{
//    text();
//    return 0;
//}



//int jieceng(int n)
//{
//    int count = 1;
//    while (n)
//    {
//        count *= n;
//        n--;
//    }
//    return count;
//}
//int main()
//{
//    int n;
//    scanf("%d", &n);
//    printf("%d", jieceng(n));
//               //就是一个数 
//    return 0;
//}



//AC 813.打印矩阵 -- 2024.12.7

//int row, col;
//void juzhen(int(*p)[col], int row, int col)
//{         //a还是a
//    for (int i = 0;i < row;i++)
//    {
//        for (int j = 0;j < col;j++)
//        {
//            printf("%d ", *(*p + j));
//        }
//        printf("\n");
//        p++;
//    }
//}
//int main()
//{
//    scanf("%d %d", &row, &col);
//    int a[row][col];
//    for (int i = 0;i < row;i++)
//    {
//        for (int j = 0;j < col;j++)
//        {
//            scanf("%d", &a[i][j]);
//        }
//    }
//    juzhen(a, row, col);
//    return 0;
//}

//       //形参这边可不初始化创建空形式二维数组，它是真不确定的，能直接应对任何
//void juzhen(int a[][100], int row, int col) 
//{  
//    for (int i = 0; i < row; i++) 
//    {
//        for (int j = 0; j < col; j++) 
//        {
//            printf("%d ", a[i][j]); 
//        }
//        printf("\n");
//    }
//}

//int main()
//{
//    int a[2][3];
//    int c[] = { 1,2,3 };//写成空的有初始化等于没空，空形式但实际没空
//    int b[][3] = { 1 };//二维数组列处不能空形式，因为二维数组初始化确定空形式写省略至少要有一个在确定的，规定是列
//    return 0;
//}



//最后指定位置的阶乘与指前位置阶乘的关系，用最后指定位置的阶乘 = 前指定位置阶乘*/表达式算
//Fact(n)已经意义为n!了

//int Fact(int n)//就像是列数学公式，1<=n<=10
//{
//    if (n == 1)
//        return 1;
//    else//(2<=n<=10)写不写都一样
//    //等于
//        return n * Fact(n - 1);
//}
//#include<stdio.h>
//int main()
//{
//    int n;
//    scanf("%d", &n);
//    printf("%d", Fact(n));
//    return 0;
//}



//int main()
//{
//    int a[2];
//    if (a < a + 1)//地址可以比大小
//        printf("hehe\n");
//    return 0;
//}



//AC 817.数组去重 -- 2024.12.8

//#include<stdio.h>  
//#include<stdlib.h>
//                   //int p[]//相当于把数组传过来了
//int get_unique_count(int* p, int n)//地址里的值已经放好确定好了，单传地址是能确定获得那些值的
//{
//    int count = n;
//    for (int i = 0;i < n;i++)
//    {
//        for (int j = 1;j < n - i;j++)
//        {
//            if (p[i] == p[i + j] && p[i] != -1)
//            {
//                count--;
//                p[i+j] = -1;//标记甚至覆盖掉
//            }
//        }
//    }
//    return count;
//}
//int main()
//{
//    int n;
//    scanf("%d", &n);
//    int a[n];
//    for (int i = 0;i < n;i++)
//    {
//        scanf("%d", &a[i]);
//    }
//    printf("%d", get_unique_count(a, n));
//    return 0;
//}

//int main()
//{
//    int n;
//    scanf("%d", &n);
//    int a[1001] = { 0 };
//    for (int i = 0;i < n;i++)
//    {
//        int x;
//        scanf("%d", &x);//再创一个数组输入数据成角标记
//        a[x] = 1;
//    }
//    int count = 0;
//    for (int i = 0;i < 1001;i++)
//    {
//        if (a[i] == 1)
//            count++;
//    }
//    printf("%d", count);
//    return 0;
//}



//#include<stdio.h>
//void sort(int* p, int l, int r)
//{
//    for (int i = 0;i < r - l;i++)
//    {
//        int b = l;
//        for (int j = 0;j < r - l - i;j++)//过程中那时外面还要的趟数等于里面比次数，动态变化的
//        {
//            if (p[b] > p[b + 1])
//            {
//                int change;
//                change = p[b];
//                p[b] = p[b + 1];
//                p[b + 1] = change;
//            }
//            b++;
//            //l++;//err --> l变改了上面的趟数和比次数
//        }
//    }
//}
//int main()
//{
//    int n, l, r;
//    scanf("%d%d%d", &n, &l, &r);
//    int a[n];
//    for (int i = 0;i < n;i++)
//    {
//        scanf("%d", &a[i]);
//    }
//    sort(a, l, r);
//    for (int i = 0;i < n;i++)
//    {
//        printf("%d ", a[i]);
//    }
//    return 0;
//}



//AC 813.打印矩阵 -- 2024.12.7

//int row, col;
//void juzhen(int(*p)[col], int row, int col)
//{         //a还是a
//    for (int i = 0;i < row;i++)
//    {
//        for (int j = 0;j < col;j++)
//        {
//            printf("%d ", *(*p + j));
//        }
//        printf("\n");
//        p++;
//    }
//}
//int main()
//{
//    scanf("%d %d", &row, &col);
//    int a[row][col];
//    for (int i = 0;i < row;i++)
//    {
//        for (int j = 0;j < col;j++)
//        {
//            scanf("%d", &a[i][j]);
//        }
//    }
//    juzhen(a, row, col);
//    return 0;
//}

//       //形参这边可不初始化创建空形式二维数组，它是真不确定的，能直接应对任何
//void juzhen(int a[][100], int row, int col) 
//{  
//    for (int i = 0; i < row; i++) 
//    {
//        for (int j = 0; j < col; j++) 
//        {
//            printf("%d ", a[i][j]); 
//        }
//        printf("\n");
//    }
//}

//int main()
//{
//    int a[2][3];
//    int c[] = { 1,2,3 };//写成空的有初始化等于没空，空形式但实际没空
//    int b[][3] = { 1 };//二维数组列处不能空形式，因为二维数组初始化确定空形式写省略至少要有一个在确定的，规定是列
//    return 0;
//}



//最后指定位置的阶乘与指前位置阶乘的关系，用最后指定位置的阶乘 = 前指定位置阶乘*/表达式算
//Fact(n)已经意义为n!了

//int Fact(int n)//就像是列数学公式，1<=n<=10
//{
//    if (n == 1)
//        return 1;
//    else//(2<=n<=10)写不写都一样
//    //等于
//        return n * Fact(n - 1);
//}
//#include<stdio.h>
//int main()
//{
//    int n;
//    scanf("%d", &n);
//    printf("%d", Fact(n));
//    return 0;
//}



//int main()
//{
//    int a[2];
//    if (a < a + 1)//地址可以比大小
//        printf("hehe\n");
//    return 0;
//}



//AC 817.数组去重 -- 2024.12.8

//#include<stdio.h>  
//#include<stdlib.h>
//                   //int p[]//相当于把数组传过来了
//int get_unique_count(int* p, int n)//地址里的值已经放好确定好了，单传地址是能确定获得那些值的
//{
//    int count = n;
//    for (int i = 0;i < n;i++)
//    {
//        for (int j = 1;j < n - i;j++)
//        {
//            if (p[i] == p[i + j] && p[i] != -1)
//            {
//                count--;
//                p[i+j] = -1;//标记甚至覆盖掉
//            }
//        }
//    }
//    return count;
//}
//int main()
//{
//    int n;
//    scanf("%d", &n);
//    int a[n];
//    for (int i = 0;i < n;i++)
//    {
//        scanf("%d", &a[i]);
//    }
//    printf("%d", get_unique_count(a, n));
//    return 0;
//}

//int main()
//{
//    int n;
//    scanf("%d", &n);
//    int a[1001] = { 0 };
//    for (int i = 0;i < n;i++)
//    {
//        int x;
//        scanf("%d", &x);//再创一个数组输入数据成角标记
//        a[x] = 1;
//    }
//    int count = 0;
//    for (int i = 0;i < 1001;i++)
//    {
//        if (a[i] == 1)
//            count++;
//    }
//    printf("%d", count);
//    return 0;
//}



//#include<stdio.h>
//void sort(int* p, int l, int r)
//{
//    for (int i = 0;i < r - l;i++)
//    {
//        int b = l;
//        for (int j = 0;j < r - l - i;j++)//过程中那时外面还要的趟数等于里面比次数，动态变化的
//        {
//            if (p[b] > p[b + 1])
//            {
//                int change;
//                change = p[b];
//                p[b] = p[b + 1];
//                p[b + 1] = change;
//            }
//            b++;
//            //l++;//err --> l变改了上面的趟数和比次数
//        }
//    }
//}
//int main()
//{
//    int n, l, r;
//    scanf("%d%d%d", &n, &l, &r);
//    int a[n];
//    for (int i = 0;i < n;i++)
//    {
//        scanf("%d", &a[i]);
//    }
//    sort(a, l, r);
//    for (int i = 0;i < n;i++)
//    {
//        printf("%d ", a[i]);
//    }
//    return 0;
//}



//力扣 125.验证回文串 -- 2024.12.11

//#include<stdbool.h>
//#include<ctype.h>
//bool isPalindrome(char* s)
//{
//    char arr[2 * 10 * 10 * 10 * 10 * 10] = { 0 };
//    char* str = arr;
//    int count = 0;
//    while (*s > 0)
//    {
//        if (isalnum(*s))
//        {//是返回值改成小写
//            *s = tolower(*s);
//            *str = *s;
//            str++;
//            count++;
//        }
//        s++;
//    }          //用逗号连续创建
////  for (int p = 0, int q =  - 1; p < q; p++, q--)
////                //err
//    for (int p = 0, q = count - 1;p < q;p++, q--)
//    {
//        if (arr[p] != arr[q])
//            return false;
//    }
//    return true;
//}
//int main()
//{
//    char brr[] = { "A man, a plan, a canal: Panama" };
//    bool a = isPalindrome(brr);
//    return 0;
//}

//不是可修改的 lvalue：在 C 中，a 被视为一个不可修改的“左值”（lvalue），即它的地址是固定的。C 语言标准规定，数组名不能作为左值修改。

//int main()
//{
//    int a[3] = { 0 };
//  //a++;//err// --> 不可修改性：数组名是一个特殊类型的指针(也是int*类型)，指向数组的首元素。这个指针的“指向”是固定的，不能被改变。因此，试图通过 a++ 来改变 a 的指向是不允许的。
//    //数组名在编译时转换为指向数组第一个元素的地址，但是这个地址不能被重定向
//    //所以
//    int* p = a;
//    p++;
//    return 0;
//}



//int main()
//{
//    int n = 5,i = 5,j = 5;
//    while(i--)//执行5次，进判断时的值是5~1(5 - 1 + 1 = 5次),进的值是4~0
//    {
//        printf("%d\n",i);
//    }printf("i出后的值 = %d\n", i);//i == -1
//    while (n-- - 2)//5 - 2 = 3,执行3次,进判断时的值是5~3(5 - 3 + 1 = 3次),进的值是4~2
//    {
//        printf("%d\n",n);
//    }
//    printf("n出后的值 = %d\n", n);//n == 1
//    while (j-- > 2)//5 - 2 = 3,执行3次,进判断时的值是5~3(5 - 3 + 1 = 3次),进的值是4~2
//    {
//        printf("%d\n", j);
//    }
//    printf("j出后的值 = %d\n", j);//j == 1
//    return 0;
//}



//力扣 08.01三步问题 -- 2024.12.13

//long long waysToStep(int n)
//{
//    const int MOD = 1000000007;
//    if (n == 1)
//        return 1;
//    if (n == 2)
//        return 2;
//    if (n == 3)
//        return 4;
//    long long a = 1, b = 2, c = 4, d;
//    while (n-- > 3)
//    {
//        d = (a + b + c) % MOD;//计算机运算时运算过程中值多大都是可以算的，拿来算的值有类型值限制，但它们运算范围没有大小限制，右边精确地算出个巨大的值后溢出是发送在赋值时，接收的变量接不下右边表达式精确的那个大值
//        //%MOD右边的表达式值限制在0~1000000006范围，a+b+c和的值如果小于1000000007，正常地出结果值，如果a+b+c和大于等于1000000007时，%MOD后结果就不再是正确的方法数了，摆烂了题目要求的给的答案标准也改成了取模之后的非方法数，答案标准是取模后的非方法数
//        a = b;//力扣 1089.复写零 -- 2024.12.15

//[0,1,7,6,0,2,0,7]//输入
//[0,1,1,7,6,0,0,2]//err
//[0,0,1,7,6,0,0,2]//right

//int brr[] = { 0,1,7,6,0,2,0,7 };
//void duplicateZeros(int* arr, int arrSize)
//{
//    int dest = -1;
//    int cur = -1;
//    while (dest < arrSize - 1)
//    {//里面本来还要同样这个判断的，调写成共用了
//        cur++;
//        if (arr[cur] == 0)
//            dest += 2;
//        else
//            dest++;
//    }//这里要出来的dest
//    //dest=arrSize-1或dest>arrSize-1
//    if (dest > arrSize - 1)
//    {
//        arr[arrSize - 1] = arr[cur];
//        dest -= 2;
//        cur--;
//    }
//    //while (cur > 0)//err
//    while(cur>=0)
//    {
//        if (arr[cur] == 0)
//        {
//            arr[dest] = 0;
//            dest--;
//        }
//        arr[dest] = arr[cur];
//        cur--;
//        dest--;
//    }
//}
//int main()
//{
//    duplicateZeros(brr, 8);
//    return 0;
//}

//int main()
//{
//    int arrSize = 2;
//    while (arrSize < 5)
//    {//进来的一定小于5的
//        arrSize+=2;//2、4
//    }//出来的一定大于等于5的
//    //6
//    return 0;
//}



//力扣202.快乐数 -- 2024.12.16

//#include<stdbool.h>
//bool isHappy(int n)
//{
//    int count = 0;
//    while (n % 10 || n / 10 > 0)
//    {
//        count += ((n % 10) * (n % 10));
//        n /= 10;
//    }
//    n = count;//定义为快指针
//    int n2 = count;//慢指针
//    count = 0;
//    do
//    {
//        while (n % 10||n/10>0)//还要考虑10的倍数模为0取到它最后一位0后拿来判断直接退出了不能接着取里面的后面位
//        {
//            count += ((n % 10) * (n % 10));
//            n /= 10;
//        }
//        n = count;
//        count = 0;
//        while (n % 10 || n / 10 > 0)
//        {
//            count += ((n % 10) * (n % 10));
//            n /= 10;
//        }
//        n = count;
//        count = 0;
//        while (n2 % 10 || n / 10 > 0)
//        {
//            count += ((n2 % 10) * (n2 % 10));
//            n2 /= 10;
//        }
//        n2 = count;
//        count = 0;
//    } while (n != n2);
//    if (n == 1)
//        return true;
//    return false;
//}
//int main()
//{
//    int n;
//    scanf("%d", &n);
//    bool a = isHappy(n);
//    printf("%d\n", a);
//    return 0;
//}



//力扣 15.三数之和 -- 2024.12.21

//输入：nums = [-1,0,1,2,-1,-4]
//输出： [[-1, -1, 2], [-1, 0, 1]]
//6
//-1 0 1 2 -1 -4
//1 - 1 0
// 
//6
//-1 0 1 2 -1 -4 -> -4 -1 -1 0 0 0 0 0 1 2
//0 0 0

//#include<stdlib.h>
//int small_compare_int(const void* p1, const void* p2)
//{
//    return *(int*)p1 - *(int*)p2;
//}
//int main()
//{
//    int arr[10] = {0}, n;
//    scanf("%d", &n);
//    for (int i = 0;i < n;i++)
//        scanf("%d", arr + i);
//    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), small_compare_int);
//    for (int i = 0;i < n;i++)
//    {
//        if (i > 0)
//        {
//            while(arr[i - 1] == arr[i])
//            {
//                i++;
//            }
//        }
//        //err int left = 0;
//        int left = i + 1;
//        int right = 10 - 1;//right始终从右端开始
//        int towsum = -arr[i];
//        while (left < right)
//        {
//            if (arr[left] + arr[right] > towsum||right == i)
//            {
//                right--;
//                while(arr[right] == arr[right + 1]&&left<right)
//                {                   
//                    right--;
//                }
//            }
//            else if (arr[left] + arr[right] < towsum||left == i)
//            {
//                left++;
//                while (arr[left - 1] == arr[left]&&left<right)
//                {
//                    left++;
//                }
//            }
//            else
//            {
//                printf("%d %d %d", arr[i], arr[left], arr[right]);
//                printf("\n");
//                left++;
//                right--;
//                while (arr[right] == arr[right + 1] && left < right)
//                {
//                    right--;
//                }
//                while (arr[left - 1] == arr[left] && left < right)
//                {
//                    left++;
//                }
//            }
//
//        }
//    }
//    return 0;
//}


 
//力扣 18.四数之和 -- 2024.12.22

//输入：nums = [1, 0, -1, 0, -2, 2], target = 0
//输出： [[-2, -1, 1, 2], [-2, 0, 0, 2], [-1, 0, 0, 1]]
//示例 2：

//输入：nums = [2, 2, 2, 2, 2], target = 8
//输出： [[2, 2, 2, 2]]

//6
//0
//1 0 -1 0 -2 2

//-2 -1 1 2
//-2 0 0 2
//-2 0 0 2
//-2 0 0 2
//-2 0 0 2

//#include<stdlib.h>
//int small_compare_int(const void* p1, void* p2)
//{
//    return *(int*)p1 - *(int*)p2;
//}
//int main()
//{
//    int arr[10] = { 0 },n,target;
//    scanf("%d%d", &n,&target);
//    for (int i = 0;i < n;i++)
//    {
//        scanf("%d", arr + i);
//    }
//    qsort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), small_compare_int);
//    for (int i = 0;i < 10;i++)
//    {
//        if (i > 0)
//        {
//            while (arr[i] == arr[i - 1]&&i<10-1)
//            {
//                i++;
//            }
//        }
//        int zan2 = i + 1;
//        while(zan2<10)
//        {
//            while (zan2 > i + 1 && arr[zan2] == arr[zan2 - 1]&&zan2<10)
//            {
//                zan2++;
//            }
//            int left = zan2 + 1;
//            int right = 10 - 1;
//            while (left < right)
//            {
//                int sum = target - arr[i] - arr[zan2];
//                if (arr[left] + arr[right] > sum)
//                {
//                    right--;
//                    while (arr[right] == arr[right + 1]&&left<right)//减了才来考虑连减的
//                    {
//                        right--;
//                    }
//                }
//                else if (arr[left] + arr[right] < sum)
//                {
//                    left++;
//                    while (arr[left] == arr[left - 1]&&left<right)
//                    {
//                        left++;
//                    }
//                }
//                else
//                {
//                    printf("%d %d %d %d", arr[i], arr[zan2], arr[left], arr[right]);
//                    printf("\n");
//                    left++;
//                    right--;
//                    while (arr[right] == arr[right + 1] && left < right)
//                    {
//                        right--;
//                    }
//                    while (arr[left] == arr[left - 1] && left < right)
//                    {
//                        left++;
//                    }
//                }
//            }
//            zan2++;
//        }
//    }
//    return 0;
//}



//力扣 209.长度最小的子数组 2024.12.23

//输入：target = 7, nums = [2,3,1,2,4,3]
//输出：2

//int arr[6] = { 2,3,1,2,4,3 };
//int minSubArrayLen(int target, int* nums, int numsSize)
//{
//    int left = 0, right = 0, sum = 0, min = numsSize, len, flag = 0;
//    sum += nums[right];
//    while (left <= right && right < numsSize)
//    {
//        if (sum >= target)
//        {
//            flag = 1;
//            len = right - left + 1;
//            if (len < min)
//                min = len;
//            sum -= nums[left];
//            left++;
//        }
//        else
//        {
//            do
//            {
//                right++;
//                if (right < numsSize)
//                    sum += nums[right];
//            } while (sum < target && right < numsSize);
//            if (sum >= target)
//            {
//                flag = 1;
//                len = right - left + 1;
//                if (len < min)
//                {
//                    min = len;
//                }
//                sum -= nums[left];
//                left++;
//            }
//        }
//    }
//    if (flag == 1)
//        return min;
//    return 0;
//}
//int main()
//{
//    int target = 7;
//    int numsSize = 6;
//    printf("%d\n", minSubArrayLen(target, arr, numsSize));
//    return 0;
//}
//        b = c;
//        c = d;
//    }
//    return d;
//}
//int main()
//{
//    int n;
//    scanf("%d", &n);
//    printf("%lld\n", waysToStep(n));
//    return 0;
//}



